﻿using DataWorks_Tools.BasicMethods;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Security;
using System.Text;
using System.Threading.Tasks;


namespace DataWorks_Tools.MergeDetails
{
    public static class Mileage
    {
        /// <summary>
        /// 利用速度和时间来计算一个csv文件的里程
        /// </summary>
        /// <param name="speed"></param>
        /// <param name="time"></param>
        /// <returns></returns>
        public static double ReturnSumDistanceperFile(List<double> speed, List<double> time)
        {
            double sumdistance=0;
            for (int i = 0; i < speed.Count - 1; i++)
            {

               var singledistance = (speed[i] + speed[i + 1]) * (time[i + 1] - time[i]) / 2 / 3.6;
                sumdistance += singledistance;
                
            }
            return sumdistance;
        }
        /// <summary>
        /// 利用速度和时间来计算一个csv文件的每行里程
        /// </summary>
        /// <param name="speed"></param>
        /// <param name="time"></param>
        /// <returns></returns>
        public static List<double> ReturnSingleDistanceperFile(List<double> speed, List<double> time)
        {
            List<double> mileagelist = new List<double>();
            mileagelist.Add(0);
            for (int i = 0; i < speed.Count - 1; i++)
            {

                var singledistance = (speed[i] + speed[i + 1]) * (time[i + 1] - time[i]) / 2 / 3.6;
                mileagelist.Add(singledistance);

            }
            return mileagelist;
        }



        public static List<List<int>> GetIndexRangesPrecise(this FileInfo[] files,List<double> list, int permileage, int spdindex)
        {
            List<List<int>> result = new List<List<int>>();
           
            var startfileindex = 0;
            var sum = 0.0;
            for (var i = 0; i < list.Count; i++)
            {
                sum += list[i];
                //先判断是否超过标准里程-5的差值，超过了才能进行下面的分割判断，没超过继续叠加
                if(sum >= permileage-5)
                {
                    //如果叠加里程达到标准单位里程的差值5米以内则不会分割单个文件
                    if (Math.Abs(sum - permileage) < 5)
                    {
                        //先判断result里面有没有数据，没有数据说明是第一次叠加里程，不用考虑起始文件的行数
                        if (result.Count == 0)
                        {
                            //倒数第二第三个数字表示起始文件的行数和终止文件的行数，都等于0表示包含所有行，不会分割单个文件，最后一个数表示终止文件分割的里程
                            result.Add(new List<int> { startfileindex, i, 0, 0,0 });
                            //startfileindex = i + 1;//这里由于终止判断了不会分割，所以下一次的起始文件index加1
                            //sum = 0;
                        }
                        //要考虑上一次是否有分割过
                        else
                        {
                            //如果前一个数据的终止文件行数有值，说明前面一个数据有分割过，那这一次的起始文件还是原来上一次的终止文件
                            if (result[result.Count - 1][3] > 0)
                            {
                                result.Add(new List<int> { result[result.Count - 1][1], i, result[result.Count - 1][3], 0,0 });
                            }
                            //说明前一个数据的终止文件行数为0，没有分割过，那这一次的起始文件就是startfileindex
                            else
                            {
                                result.Add(new List<int> { startfileindex, i,0, 0,0 });
                            }
                                                     
                        }
                        startfileindex = i + 1;//这里由于终止文件判断了不会分割，所以下一次的起始文件index加1
                        sum = 0;
                    }
                    //差值超过5就会分割文件
                    else
                    {

                        //获得准确差值
                        var diff = sum - permileage;
                        //获得要分割文件的速度list
                        var spdlist = CSVHelperClass.GetDataFromColumnIdx(files[i], spdindex);
                        //获得要分割文件的timelist
                        var timelist = CSVHelperClass.GetDataFromColumnIdx(files[i], 0);
                        if (spdlist != null && timelist != null)
                        {
                            var mileage = Mileage.ReturnSingleDistanceperFile(spdlist, timelist);//计算这个文件的每行里程数
                            var singlesum = 0.0;
                            //倒序循环叠加每行里程，如超过差值停止循环，找到此文件要分割的行数
#pragma warning disable CS0162 // 检测到无法访问的代码
                            for (int j = mileage.Count - 1; j >= 0; j--)
                            {
                                singlesum += mileage[j];
                                if (singlesum >= diff)
                                {
                                    if (result.Count == 0)
                                    {
                                        result.Add(new List<int> { startfileindex, i, 0, j, Convert.ToInt32(diff)});
                                    
                                    }
                                    //说明result之前有值
                                    else
                                    {
                                        //如果前一个数据的终止文件行数有值，说明前面一个数据有分割过，那这一次的起始文件还是原来上一次的终止文件
                                        if (result[result.Count - 1][3] > 0)
                                        {
                                            //这一次的起始文件为上一次的终止文件，终止文件为i，起始行数为前一次的终止文件的行数，终止文件的行数为j，里程差值为diff
                                            result.Add(new List<int> { result[result.Count - 1][1], i, result[result.Count - 1][3], j, Convert.ToInt32(diff) });
                                        }
                                        else
                                        {
                                            result.Add(new List<int> { startfileindex, i, 0, j, Convert.ToInt32(diff) });
                                        }
                                        startfileindex = i;//由于这一次分割过，所以下一次的起始文件还是i
                                        sum = diff;//由于这一次分割过，所以下一次的sum计数要从diff算起
                                    }
                                }
                                break;//停止循环
                            }
#pragma warning restore CS0162 // 检测到无法访问的代码

                        }
                      
                    }
                }
            
            }
            //文件循环结束后startfileindex没有到最后一个文件时，说明合并完后还有剩余文件加起来没有到标准里程
            if (startfileindex < list.Count)
            {
                //说明所有文件加起来的里程没有超过1km
                if(result.Count == 0)
                {
                    result.Add(new List<int> { startfileindex, list.Count - 1,0,0,0 });
                }
                else
                {
                    //说明前面一组有分割
                    if(result[result.Count - 1][3] > 0)
                    {
                        result.Add(new List<int> { result[result.Count - 1][1], list.Count - 1, result[result.Count - 1][3], 0, 0 });

                    }
                    //说明前面一组没有分割
                    else
                    {
                        result.Add(new List<int> { startfileindex, list.Count - 1, 0, 0, 0 });
                    }
                }
            }
            return result;
        }


    }
}
